package com.fjnu.service.impl;

import com.fjnu.annotation.ExceptionGlobalCatch;
import com.fjnu.dao.ArticleDao;
import com.fjnu.dao.UserDao;
import com.fjnu.dto.ArticleConditionDto;
import com.fjnu.dto.ArticleUpdateDto;
import com.fjnu.entity.Article;
import com.fjnu.service.ArticleService;
import com.fjnu.utils.PageResult;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.time.LocalDateTime;
import java.util.List;

/**
 * 文章服务实现类
 */
@Service
@ExceptionGlobalCatch
public class ArticleServiceImpl implements ArticleService {
    
    @Autowired
    private ArticleDao articleDao;
    
    @Autowired
    private UserDao userDao;
    
    @Override
    public PageResult queryByArticleCondition(ArticleConditionDto articleCond, Integer pageNum, Integer pageSize) {
        // 计算起始索引
        int startIndex = (pageNum - 1) * pageSize;
        
        // 获取符合条件的文章列表
        List<Article> articles = articleDao.selectByConditionWithLimit(articleCond, startIndex, pageSize);
        
        // 获取总记录数
        int total = articleDao.countByCondition(articleCond);
        
        // 创建并返回PageResult对象
        return new PageResult((long) total, pageNum, pageSize, articles);
    }
    
    @Override
    public Article queryById(String articleId) {
        return articleDao.selectById(Integer.parseInt(articleId));
    }
    
    @Override
    @Transactional
    public Article insertArticle(Article article) {
        // 检查必要字段
        if (article.getUserId() == null) {
            throw new IllegalArgumentException("用户ID不能为空");
        }
        
        if (article.getTitle() == null || article.getTitle().isEmpty()) {
            throw new IllegalArgumentException("文章标题不能为空");
        }
        
        if (article.getContent() == null || article.getContent().isEmpty()) {
            throw new IllegalArgumentException("文章内容不能为空");
        }
        
        if (article.getCategoryId() == null) {
            throw new IllegalArgumentException("分类ID不能为空");
        }
        
        article.setCreateTime(LocalDateTime.now());
        article.setUpdateTime(LocalDateTime.now());
        article.setStatus(0); // 默认状态为未发布
        
        int result = articleDao.insert(article);
        
        // 如果插入失败，抛出异常以触发事务回滚
        if (result <= 0) {
            throw new RuntimeException("文章新增失败");
        }
        
        // 如果article的id仍然为null，尝试重新查询获取刚插入的文章
        if (article.getId() == null) {
            // 可以通过查询数据库获取刚插入的文章，这里简化处理
            // 实际项目中，应该在DAO层使用SELECT LAST_INSERT_ID()等方式获取新插入记录的ID
            return article;
        }
        
        return article;
    }
    
    @Override
    @Transactional
    public int publishArticle(String articleId, String userId) {
        try {
            // 更新文章状态为已发布(1)
            int result = articleDao.updateStatus(Integer.parseInt(articleId), 1);
            
            // 如果文章发布成功，则增加用户积分
            if (result > 0) {
                // 给用户增加积分，假设每次发布文章增加10分
                userDao.updateScore(Integer.parseInt(userId), 10L);
                return 1;
            }
            return 0;
        } catch (Exception e) {
            // 发生异常时回滚事务
            throw new RuntimeException("发布文章失败", e);
        }
    }
    
    @Override
    @Transactional
    public int publishArticlesByBatch(String[] articleIds, String userId) {
        try {
            // 批量更新文章状态
            // 注意：当前DAO没有提供直接接受String[]参数的方法，需要转换
            new java.util.ArrayList<String>(); // 仅为了引入ArrayList类
            java.util.List<Integer> ids = new java.util.ArrayList<>();
            for (String articleId : articleIds) {
                ids.add(Integer.parseInt(articleId));
            }
            
            int totalUpdated = articleDao.batchUpdateStatus(ids, 1);
            
            // 如果有文章发布成功，则增加用户积分
            if (totalUpdated > 0) {
                // 给用户增加积分，每篇文章10分
                userDao.updateScore(Integer.parseInt(userId), (long) (totalUpdated * 10));
                return 1;
            }
            return 0;
        } catch (Exception e) {
            // 发生异常时回滚事务
            throw new RuntimeException("批量发布文章失败", e);
        }
    }
    
    @Override
    @Transactional
    public int updateArticle(ArticleUpdateDto articleUpdateDto) {
        // 检查必要字段
        if (articleUpdateDto.getId() == null) {
            throw new IllegalArgumentException("文章ID不能为空");
        }
        
        // 创建ArticleConditionDto对象用于更新
        ArticleConditionDto updateCondition = new ArticleConditionDto();
        updateCondition.setTitle(articleUpdateDto.getTitle());
        updateCondition.setContent(articleUpdateDto.getContent());
        updateCondition.setCategoryId(articleUpdateDto.getCategoryId());
        updateCondition.setDescription(articleUpdateDto.getDescription());
        
        // 调用DAO方法更新文章
        int result = articleDao.updateByCondition(articleUpdateDto.getId(), updateCondition);
        
        // 如果更新成功，更新文章的updateTime
        if (result > 0) {
            articleDao.updateUpdateTime(articleUpdateDto.getId(), LocalDateTime.now());
        }
        
        return result;
    }
    
    @Override
    @Transactional
    public int removeArticle(String articleId, String userId) {
        try {
            // 删除文章
            int result = articleDao.deleteById(Integer.parseInt(articleId));
            
            // 如果文章删除成功，则减少用户积分
            if (result > 0) {
                // 删除文章时减少用户积分，假设每次删除文章减少5分
                userDao.updateScore(Integer.parseInt(userId), -5L);
                return 1;
            }
            return 0;
        } catch (Exception e) {
            // 发生异常时回滚事务
            throw new RuntimeException("删除文章失败", e);
        }
    }
}